home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Frameworks / TransSkel 3.24 / Demos / Pascal Demos / DialogSkel / DialogSkel.p next >
Text File  |  1996-01-24  |  11KB  |  493 lines
  1. { TransSkel DialogSkel application in Pascal }
  2.  
  3. { 11 Feb 94 Version 1.00, Paul DuBois }
  4.  
  5. program DialogSkel;
  6.  
  7.     uses
  8.         Types, Memory, Events, QuickDraw, Windows, Dialogs, Menus, Icons,
  9.         TextEdit, Scrap, ToolUtils, TransSkel;
  10.  
  11.     const
  12.  
  13.         normalHilite = 0;
  14.         dimHilite = 255;
  15.  
  16.         fileMenuID = skelAppleMenuID + 1;
  17.         editMenuID = fileMenuID + 1;
  18.  
  19.         mDlogRes = 1000;
  20.         aboutAlrtRes = 1001;
  21.         docWindRes = 1000;
  22.  
  23.         showDlog1 = 1;
  24.         showDlog2 = 2;
  25.         showDoc = 3;
  26.         closeWind = 4;
  27. { separator line }
  28.         quit = 6;
  29.  
  30.         undo = 1;
  31. { separator line }
  32.         cut = 3;
  33.         copy = 4;
  34.         paste = 5;
  35.         clear = 6;
  36.  
  37.         button1 = 1;
  38.         edit1 = 2;
  39.         static1 = 3;
  40.         radio1 = 4;
  41.         radio2 = 5;
  42.         radio3 = 6;
  43.         check1 = 7;
  44.         check2 = 8;
  45.         user1 = 9;
  46.  
  47.     var
  48.  
  49.         mDlog1: DialogPtr;
  50.         mDlog2: DialogPtr;
  51.         docWind: WindowPtr;
  52.         iconNum1: Integer;
  53.         iconNum2: Integer;
  54.  
  55.         fileMenu: MenuHandle;
  56.         editMenu: MenuHandle;
  57.  
  58.         drawIconProc: UserItemUPP;
  59.         
  60.         hidden1: Boolean;            { flags for keeping track of dialog }
  61.         hidden2: Boolean;            { visibility when a suspend occurs }
  62.  
  63. {--------------------------------------------------------------------}
  64. { Miscellaneous stuff }
  65. {--------------------------------------------------------------------}
  66.  
  67.     procedure DrawIcon (dlog: DialogPtr;
  68.                                     item: Integer);
  69.         var
  70.             h: Handle;
  71.             r: Rect;
  72.     begin
  73.         SkelGetDlogRect(dlog, item, r);
  74.         if (dlog = mDlog1) then
  75.             h := GetIcon(iconNum1)
  76.         else
  77.             h := GetIcon(iconNum2);
  78.         PlotIcon(r, h);
  79.     end;
  80.  
  81.  
  82.     procedure SetDlogRadio (dlog: DialogPtr;
  83.                                     item: Integer);
  84.         var
  85.             partner: DialogPtr;
  86.             tmpPort: GrafPtr;
  87.             r: Rect;
  88.     begin
  89.         partner := DialogPtr(GetWRefCon(dlog));
  90.         SkelSetDlogRadioButtonSet(dlog, radio1, radio3, item);
  91.  
  92.         if (partner = mDlog1) then
  93.             iconNum1 := item - radio1
  94.         else
  95.             iconNum2 := item - radio1;
  96.  
  97.         SkelGetDlogRect(partner, user1, r);
  98.         GetPort(tmpPort);
  99.         SetPort(partner);
  100.         InvalRect(r);        { invalidate item rect to generate update rect }
  101.         SetPort(tmpPort);
  102.     end;
  103.  
  104.  
  105. {--------------------------------------------------------------------}
  106. { Dialog window setup and handler routines }
  107. {--------------------------------------------------------------------}
  108.  
  109.  
  110.     function DlogFilter (dlog: DialogPtr;
  111.                                     var evt: EventRecord;
  112.                                     var item: Integer): Boolean;
  113.         var
  114.             hilite: Integer;
  115.             c: char;
  116.             str: Str255;
  117.             ignore: Boolean;
  118.     begin
  119.         DlogFilter := false;
  120.         SkelGetDlogStr(dlog, edit1, str);
  121.         if (length(str) = 0) then
  122.             hilite := dimHilite
  123.         else
  124.             hilite := normalHilite;
  125.         if ((evt.what = activateEvt) and (BitAnd(evt.modifiers, activeFlag) = 0)) then
  126.             hilite := dimHilite;
  127.         if (dlog <> FrontWindow) then
  128.             hilite := dimHilite;
  129.         if (SkelSetDlogCtlHilite(dlog, button1, hilite)) then
  130.             SkelDrawButtonOutline(SkelGetDlogCtl(dlog, button1));
  131.         case evt.what of
  132.             nullEvent: 
  133.                 SkelSetDlogCursor(dlog);
  134.             keyDown: 
  135.                 DlogFilter := SkelDlogMapKeyToButton(dlog, evt, item, button1, 0);
  136.             updateEvt: 
  137.                 SkelDrawButtonOutline(SkelGetDlogCtl(dlog, button1));
  138.             activateEvt:
  139. { Accept button and outline are set above.  Set other controls here. }
  140.                 begin
  141.                     if (BitAnd(evt.modifiers, activeFlag) <> 0) then
  142.                         hilite := normalHilite
  143.                     else
  144.                         hilite := dimHilite;
  145.                     ignore := SkelSetDlogCtlHilite(dlog, radio1, hilite);
  146.                     ignore := SkelSetDlogCtlHilite(dlog, radio2, hilite);
  147.                     ignore := SkelSetDlogCtlHilite(dlog, radio3, hilite);
  148.                     ignore := SkelSetDlogCtlHilite(dlog, check1, hilite);
  149.                     ignore := SkelSetDlogCtlHilite(dlog, check2, hilite);
  150.                 end;
  151.         end;
  152.     end;
  153.  
  154.  
  155.     procedure DlogSelect (actor: DialogPtr;
  156.                                     item: Integer);
  157.         var
  158.             partner: DialogPtr;
  159.             title: Str255;
  160.     begin
  161.         partner := DialogPtr(GetWRefCon(actor));
  162.         case item of
  163.             button1: 
  164.                 begin
  165.                     SkelGetDlogStr(actor, edit1, title);
  166.                     SetWTitle(partner, title);
  167.                 end;
  168.             radio1, radio2, radio3: 
  169.                 SetDlogRadio(actor, item);
  170.             check1: 
  171.                 if (SkelToggleDlogCtlValue(actor, item) <> 0) then
  172.                     ShowWindow(partner)
  173.                 else
  174.                     HideWindow(partner);
  175.             check2: 
  176.                 if (SkelToggleDlogCtlValue(actor, item) <> 0) then
  177.                     WindowPeek(partner)^.goAwayFlag := Boolean(255)
  178.                 else
  179.                     WindowPeek(partner)^.goAwayFlag := Boolean(0);
  180.         end;
  181.     end;
  182.  
  183.  
  184.     procedure DlogClose;
  185.         var
  186.             actor: DialogPtr;
  187.             partner: DialogPtr;
  188.     begin
  189.         GetPort(actor);
  190.         partner := DialogPtr(GetWRefCon(actor));
  191.         HideWindow(actor);
  192.         SkelSetDlogCtlValue(partner, check1, 0);
  193.     end;
  194.  
  195.  
  196.     procedure DlogClobber;
  197.         var
  198.             dlog: DialogPtr;
  199.     begin
  200.         GetPort(dlog);
  201.         DisposeDialog(dlog);
  202.     end;
  203.  
  204.  
  205.     function DemoDialog (title: Str255;
  206.                                     h: Integer;
  207.                                     v: Integer): DialogPtr;
  208.         var
  209.             dlog: DialogPtr;
  210.             ignore: Boolean;
  211.     begin
  212.         dlog := GetNewDialog(mDlogRes, nil, WindowPtr(-1));
  213.         MoveWindow(dlog, h, v, false);
  214.         SetWTitle(dlog, title);
  215.         ignore := SkelDialog(dlog, @DlogFilter, @DlogSelect, @DlogClose, @DlogClobber);
  216.         DemoDialog := dlog;
  217.     end;
  218.  
  219.  
  220. {--------------------------------------------------------------------}
  221. { Document window setup and handler routines }
  222. {--------------------------------------------------------------------}
  223.  
  224.  
  225.     procedure DocUpdate (resized: Boolean);
  226.     begin
  227.     end;
  228.  
  229.  
  230.     procedure DocActivate (active: Boolean);
  231.     begin
  232.     end;
  233.  
  234.  
  235.     procedure DocClobber;
  236.     begin
  237.         HideWindow(docWind);
  238.         DisposeWindow(docWind);
  239.     end;
  240.  
  241.  
  242.     procedure DocWindow (h: Integer;
  243.                                     v: Integer);
  244.         var
  245.             ignore: Boolean;
  246.     begin
  247.         if (SkelQuery(skelQHasColorQD) <> 0) then
  248.             docWind := GetNewCWindow(docWindRes, nil, WindowPtr(-1))
  249.         else
  250.             docWind := GetNewWindow(docWindRes, nil, WindowPtr(-1));
  251.         ignore := SkelWindow(docWind, nil, nil, @DocUpdate, @DocActivate, nil, @DocClobber, nil, false);
  252.         MoveWindow(docWind, h, v, false);
  253.     end;
  254.  
  255.  
  256. {--------------------------------------------------------------------}
  257. { Menu handlers }
  258. {--------------------------------------------------------------------}
  259.  
  260.  
  261. { Handle selection of "About Button..." item from Apple menu }
  262.  
  263.     procedure DoAppleMenu (item: Integer);
  264.         var
  265.             ignore: Integer;
  266.     begin
  267.         ignore := SkelAlert(aboutAlrtRes, SkelDlogFilter(nil, true), skelPositionOnParentDevice);
  268.         SkelRmveDlogFilter;
  269.     end;
  270.  
  271.  
  272. { Process selection from File menu }
  273.  
  274.     procedure DoFileMenu (item: Integer);
  275.     begin
  276.         case item of
  277.             showDlog1: 
  278.                 begin
  279.                     SelectWindow(mDlog1);
  280.                     ShowWindow(mDlog1);
  281.                     SkelSetDlogCtlValue(mDlog2, check1, 1);
  282.                 end;
  283.             showDlog2: 
  284.                 begin
  285.                     SelectWindow(mDlog2);
  286.                     ShowWindow(mDlog2);
  287.                     SkelSetDlogCtlValue(mDlog1, check1, 1);
  288.                 end;
  289.             showDoc: 
  290.                 begin
  291.                     SelectWindow(docWind);
  292.                     ShowWindow(docWind);
  293.                 end;
  294.             closeWind: 
  295.                 SkelClose(FrontWindow);
  296.             quit: 
  297.                 SkelStopEventLoop;
  298.         end;
  299.     end;
  300.  
  301.  
  302.     procedure DoEditMenu (item: Integer);
  303.         var
  304.             dlog: DialogPtr;
  305.             ignore: Integer;
  306.     begin
  307.         if (SystemEdit(item - 1)) then    { if DA handled operation, return }
  308.             exit(DoEditMenu);
  309.  
  310. { if front window is document window, do nothing }
  311.         dlog := DialogPtr(FrontWindow);
  312.         if (WindowPeek(dlog)^.windowKind <> dialogKind) then
  313.             exit(DoEditMenu);
  314.         case item of
  315.             cut: 
  316.                 begin
  317.                     DialogCut(dlog);
  318.                     ignore := ZeroScrap;
  319.                     ignore := TEToScrap;
  320.                 end;
  321.             copy: 
  322.                 begin
  323.                     DialogCopy(dlog);
  324.                     ignore := ZeroScrap;
  325.                     ignore := TEToScrap;
  326.                 end;
  327.             paste: 
  328.                 begin
  329.                     ignore := TEFromScrap;
  330.                     DialogPaste(dlog);
  331.                 end;
  332.             clear: 
  333.                 DialogDelete(dlog);
  334.         end;
  335.     end;
  336.  
  337.  
  338. { Adjust menus when mouse click occurs in menu bar, }
  339. { before menus are shown. }
  340.  
  341.     procedure AdjustMenus;
  342.         var
  343.             w: WindowPtr;
  344.     begin
  345.         w := FrontWindow;
  346.         if (w = nil) then
  347.             DisableItem(fileMenu, closeWind)
  348.         else
  349.             EnableItem(fileMenu, closeWind);
  350.         if (w = docWind) then
  351.             begin
  352.                 DisableItem(editMenu, undo);
  353.                 DisableItem(editMenu, cut);
  354.                 DisableItem(editMenu, copy);
  355.                 DisableItem(editMenu, paste);
  356.                 DisableItem(editMenu, clear);
  357.             end
  358.         else
  359.             begin
  360.                 { modeless dialog or DA -- dim undo for dialogs }
  361.                 if (WindowPeek(w)^.windowKind = dialogKind) then
  362.                     DisableItem(editMenu, undo)
  363.                 else
  364.                     EnableItem(editMenu, undo);
  365.  
  366.                 EnableItem(editMenu, cut);
  367.                 EnableItem(editMenu, copy);
  368.                 EnableItem(editMenu, paste);
  369.                 EnableItem(editMenu, clear);
  370.             end;
  371.     end;
  372.  
  373.  
  374. {--------------------------------------------------------------------}
  375. { Suspend/resume handler }
  376. {--------------------------------------------------------------------}
  377.  
  378.  
  379.     procedure SuspendResume (inForeground: Boolean);
  380.         var
  381.             w: WindowPtr;
  382.             event: EventRecord;
  383.             ignore: Boolean;
  384.     begin
  385.         if (inForeground = false) then
  386.             begin
  387.                 hidden1 := false;
  388.                 hidden2 := false;
  389.                 if (WindowPeek(mDlog1)^.visible) then
  390.                     begin
  391.                         ShowHide(mDlog1, false);
  392.                         hidden1 := true;
  393.                     end;
  394.                 if (WindowPeek(mDlog2)^.visible) then
  395.                     begin
  396.                         ShowHide(mDlog2, false);
  397.                         hidden2 := true;
  398.                     end;
  399.                 w := FrontWindow;
  400.                 if (w <> nil) then
  401.                     begin
  402.                         HiliteWindow(w, false);
  403.                         SkelActivate(w, false);
  404.                     end;
  405.             end
  406.         else
  407.             begin
  408.                 w := FrontWindow;
  409.                 if (w <> nil) then
  410.                     HiliteWindow(w, false);
  411.                 if (hidden1) then
  412.                     ShowHide(mDlog1, true);
  413.                 if (hidden2) then
  414.                     ShowHide(mDlog2, true);
  415.                 w := FrontWindow;
  416.                 if (w <> nil) then
  417.                     begin
  418.                         HiliteWindow(w, true);
  419.                         SkelActivate(w, true);
  420.                     end;
  421.                 if (EventAvail(mDownMask, event)) then
  422.                     ignore := GetNextEvent(mDownMask, event);
  423.             end;
  424.     end;
  425.  
  426.  
  427. {--------------------------------------------------------------------}
  428. { Main program }
  429. {--------------------------------------------------------------------}
  430.  
  431.  
  432.     procedure Initialize;
  433.         var
  434.             ignore: Boolean;
  435.     begin
  436.         iconNum1 := 0;
  437.         iconNum2 := 0;
  438.  
  439.         SkelInit(nil);
  440.  
  441.         SkelSetSuspendResume(@SuspendResume);
  442.  
  443.         SkelApple('About DialogSkel…', @DoAppleMenu);
  444.  
  445.         fileMenu := NewMenu(fileMenuID, 'File');
  446.         AppendMenu(fileMenu, 'Show Dialog 1;Show Dialog 2;Show Doc Window');
  447.         AppendMenu(fileMenu, 'Close/W;(-;Quit/Q');
  448.         ignore := SkelMenu(fileMenu, @DoFileMenu, nil, false, false);
  449.  
  450.         editMenu := NewMenu(editMenuID, 'Edit');
  451.         AppendMenu(editMenu, '(Undo/Z;(-;Cut/X;Copy/C;Paste/V;Clear');
  452.         ignore := SkelMenu(editMenu, @DoEditMenu, nil, false, false);
  453.  
  454.         DrawMenuBar;
  455.         SkelSetMenuHook(@AdjustMenus);
  456.  
  457.         DocWindow(100, 125);
  458.  
  459.         mDlog1 := DemoDialog('Modeless Dialog 1', 50, 50);
  460.         mDlog2 := DemoDialog('Modeless Dialog 2', 150, 200);
  461.         SetWRefCon(mDlog1, LongInt(mDlog2));
  462.         SetWRefCon(mDlog2, LongInt(mDlog1));
  463.         SkelSetDlogStr(mDlog1, edit1, 'Modeless Dialog 2');
  464.         SkelSetDlogStr(mDlog2, edit1, 'Modeless Dialog 1');
  465.  
  466.         drawIconProc := NewUserItemProc (@DrawIcon);
  467.         SkelSetDlogProc(mDlog1, user1, drawIconProc);
  468.         SkelSetDlogProc(mDlog2, user1, drawIconProc);
  469.  
  470.         SkelSetDlogRadioButtonSet(mDlog1, radio1, radio3, radio1);
  471.         SkelSetDlogRadioButtonSet(mDlog2, radio1, radio3, radio1);
  472.         SkelSetDlogCtlValue(mDlog1, check1, 1);
  473.         SkelSetDlogCtlValue(mDlog2, check1, 1);
  474.         SkelSetDlogCtlValue(mDlog1, check2, 1);
  475.         SkelSetDlogCtlValue(mDlog2, check2, 1);
  476.  
  477.         SelectWindow(docWind);
  478.         ShowWindow(docWind);
  479.         SkelDoEvents(activMask + updateMask);
  480.         SelectWindow(mDlog1);
  481.         ShowWindow(mDlog1);
  482.         SkelDoEvents(activMask + updateMask);
  483.         SelectWindow(mDlog2);
  484.         ShowWindow(mDlog2);
  485.         SkelDoEvents(activMask + updateMask);
  486.     end;
  487.  
  488.  
  489. begin
  490.     Initialize;
  491.     SkelEventLoop;
  492.     SkelCleanup;
  493. end.